"""
Case Type   : 共享存储-系统内部工具-dsscmd
Case Name   : dsscmd工具将节点从集群中移除，不走服务端
Create At   : 2023/4/20
Owner       : opentestcase019
Description :
    1.将节点从集群中移除，查看帮助信息
    2.在主机和备机执行将节点从集群中移除，不走服务端，不指定参数
    3.将节点从集群中移除，不走服务端，指定-t type参数为有效值
    4.将节点从集群中移除，不走服务端，指定-t type参数为无效值
    5.分别在主机和备机执行将节点从集群中移除，不走服务端，指定-D DSS_HOME参数为正常值
    6.将节点从集群中移除，不走服务端，指定错误的-D DSS_HOME参数
    7.将节点从集群中移除，不走服务端，指定权限不足的-D DSS_HOME参数
    8.在dss关闭的情况下执行将节点从集群中移除，不走服务端
    9.在集群停止的情况下执行;expect:将节点从集群中移除成功
    10.DSS_HOME路径权限不足时，将节点从集群中移除，不走服务端，不指定-D DSS_HOME参数
Expect      :
    1.查看成功
    2.将节点从集群中移除成功
    3.将节点从集群中移除成功
    4.合理报错
    5.将节点从集群中移除成功
    6.合理报错
    7.合理报错
    8.将节点从集群中移除成功
    9.将节点从集群中移除成功
    10.合理报错
History     :
"""
import os
import time
import unittest
from yat.test import Node
from yat.test import macro
from testcase.utils.Logger import Logger
from testcase.utils.Common import Common
from testcase.utils.CommonSH import CommonSH
from testcase.utils.Constant import Constant

Primary_SH = CommonSH('PrimaryDbUser')


@unittest.skipIf(1 == Primary_SH.get_node_num(), '单机环境不执行')
class ShareStorageTool(unittest.TestCase):
    def setUp(self):
        self.logger = Logger()
        self.logger.info(f"-----{os.path.basename(__file__)} start-----")
        self.primary_node = Node('PrimaryDbUser')
        self.primary_sh = CommonSH('PrimaryDbUser')
        self.standby_node = Node('Standby1DbUser')
        self.common = Common()
        self.constant = Constant()

    def test_sharestorage_tool(self):
        step1 = "-----step1:将节点从集群中移除，查看帮助信息;expect:查看成功-----"
        self.logger.info(step1)
        execute_cmd = f"source {macro.DB_ENV_PATH};dsscmd unreghl -h"
        self.logger.info(execute_cmd)
        execute_msg = self.common.get_sh_result(self.primary_node, execute_cmd)
        self.assertIn('Usage:dsscmd unreghl [-t type] [-D DSS_HOME]\n'
                      '[manage command] unregister host from array\n'
                      '-t/--type <type>, [optional], value is int, '
                      '0 without lock, otherwise with lock\n'
                      '-D/--DSS_HOME <DSS_HOME>, [optional], the run path '
                      'of dssserver, default value is $DSS_HOME',
                      execute_msg, "执行失败" + step1)

        step2 = "-----step2:在主机和备机执行将节点从集群中移除，不走服务端，" \
                "不指定参数;expect:将节点从集群中移除成功-----"
        self.logger.info(step2)
        execute_cmd = f"source {macro.DB_ENV_PATH};" \
            f"dsscmd unreghl;"
        self.logger.info(execute_cmd)
        execute_msg = self.common.get_sh_result(self.primary_node, execute_cmd)
        self.assertIn('Succeed to unregister.', execute_msg, "执行失败" + step2)
        for i in range(30):
            status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
            self.logger.info(status)
            if "OffLine" in status:
                break
        time.sleep(60)
        status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
        self.logger.info(status)
        self.assertIn("cluster_state   : Normal", status, "执行失败" + step2)
        self.logger.info("-----在备机执行-----")
        execute_msg = self.common.get_sh_result(self.standby_node, execute_cmd)
        self.assertIn('Succeed to unregister.', execute_msg, "执行失败" + step2)
        for i in range(30):
            status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
            self.logger.info(status)
            if "OffLine" in status:
                break
        time.sleep(60)
        status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
        self.logger.info(status)
        self.assertIn("cluster_state   : Normal", status, "执行失败" + step2)

        step3 = "-----step3:将节点从集群中移除，不走服务端，" \
                "指定-t type参数为有效值;expect:将节点从集群中移除成功-----"
        self.logger.info(step3)
        cmd_list = ['-t 0', '-t 1', '-t 23',
                    '--type 0', '--type 1', '--type 23']
        for cmd in cmd_list:
            execute_cmd = f"source {macro.DB_ENV_PATH};" \
                f"dsscmd unreghl {cmd};"
            self.logger.info(execute_cmd)
            execute_msg = self.common.get_sh_result(self.primary_node,
                                                    execute_cmd)
            self.assertIn('Succeed to unregister.', execute_msg,
                          "执行失败" + step3)
            for i in range(30):
                status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
                self.logger.info(status)
                if "OffLine" in status:
                    break
            time.sleep(60)
            status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
            self.logger.info(status)
            self.assertIn("cluster_state   : Normal", status, "执行失败" + step3)

        step4 = "-----step4:将节点从集群中移除，不走服务端，" \
                "指定-t type参数为无效值;expect:合理报错-----"
        self.logger.info(step4)
        cmd_list = ['-t zero', '-t %&@', '-t 1@']
        for cmd in cmd_list:
            execute_cmd = f"source {macro.DB_ENV_PATH};" \
                f"dsscmd unreghl {cmd};"
            self.logger.info(execute_cmd)
            execute_msg = self.common.get_sh_result(self.primary_node,
                                                    execute_cmd)
            self.assertIn('The value of type is invalid.',
                          execute_msg, "执行失败" + step4)

        step5 = "-----step5:分别在主机和备机执行将节点从集群中移除，不走服务端，" \
                "指定-D DSS_HOME参数为正常值;expect:将节点从集群中移除成功-----"
        self.logger.info(step5)
        execute_cmd = f"source {macro.DB_ENV_PATH};" \
            f"dsscmd unreghl -t 0 -D {macro.DSS_INSTANCE};"
        self.logger.info(execute_cmd)
        execute_msg = self.common.get_sh_result(self.primary_node, execute_cmd)
        self.assertIn('Succeed to unregister.', execute_msg, "执行失败" + step5)
        for i in range(30):
            status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
            self.logger.info(status)
            if "OffLine" in status:
                break
        time.sleep(60)
        status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
        self.logger.info(status)
        self.assertIn("cluster_state   : Normal", status, "执行失败" + step5)
        self.logger.info("-----在备机执行-----")
        execute_msg = self.common.get_sh_result(self.standby_node, execute_cmd)
        self.assertIn('Succeed to unregister.', execute_msg, "执行失败" + step5)
        for i in range(30):
            status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
            self.logger.info(status)
            if "OffLine" in status:
                break
        time.sleep(60)
        status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
        self.logger.info(status)
        self.assertIn("cluster_state   : Normal", status, "执行失败" + step5)

        step6 = "-----step6:将节点从集群中移除，不走服务端，" \
                "指定错误的-D DSS_HOME参数;expect:合理报错-----"
        self.logger.info(step6)
        execute_cmd = f"source {macro.DB_ENV_PATH};" \
            f"dsscmd unreghl -t 0 -D {macro.DSS_INSTANCE}.bak;"
        self.logger.info(execute_cmd)
        execute_msg = self.common.get_sh_result(self.primary_node, execute_cmd)
        self.assertIn('Failed to unregister.', execute_msg, "执行失败" + step6)

        step7 = "-----step7:将节点从集群中移除，不走服务端，" \
                "指定权限不足的-D DSS_HOME参数;expect:合理报错-----"
        self.logger.info(step7)
        execute_cmd = f"source {macro.DB_ENV_PATH};" \
            f"chmod 000 {macro.DSS_INSTANCE};" \
            f"dsscmd unreghl -D {macro.DSS_INSTANCE};" \
            f"chmod 700 {macro.DSS_INSTANCE}"
        self.logger.info(execute_cmd)
        execute_msg = self.common.get_sh_result(self.primary_node, execute_cmd)
        self.assertIn("dss_inst.ini does not exist", execute_msg,
                      "执行失败" + step6)
        self.assertIn("Failed to unregister", execute_msg, "执行失败" + step6)

        step8 = "-----step8:在dss关闭的情况下执行将节点从集群中移除，" \
                "不走服务端;expect:将节点从集群中移除成功-----"
        self.logger.info(step8)
        execute_cmd = f"source {macro.DB_ENV_PATH};" \
            f"dsscmd stopdss;sleep 2;" \
            f"dsscmd unreghl;" \
            f"dsscmd unreghl -D {macro.DSS_INSTANCE};"
        self.logger.info(execute_cmd)
        execute_msg = self.common.get_sh_result(self.standby_node, execute_cmd)
        self.assertIn('Succeed to stop server', execute_msg, "执行失败" + step8)
        self.assertEquals(2, execute_msg.count("Succeed to unregister"),
                          "执行失败" + step8)
        for i in range(30):
            status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
            self.logger.info(status)
            if "OffLine" in status:
                break
        time.sleep(60)
        status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
        self.logger.info(status)
        self.assertIn("cluster_state   : Normal", status, "执行失败" + step8)

        step9 = "-----step9:在集群停止的情况下执行;expect:将节点从集群中移除成功-----"
        self.logger.info(step9)
        stop_msg = self.primary_sh.exec_cm_ctl(mode='stop')
        self.logger.info(stop_msg)
        self.assertIn(self.constant.cm_stop_success_msg,
                      stop_msg, '执行失败' + step9)
        execute_cmd = f"source {macro.DB_ENV_PATH};dsscmd unreghl;" \
            f"dsscmd unreghl -D {macro.DSS_INSTANCE};"
        self.logger.info(execute_cmd)
        execute_msg = self.common.get_sh_result(self.primary_node, execute_cmd)
        self.assertIn('Succeed to unregister.', execute_msg, "执行失败" + step9)
        start_msg = self.primary_sh.exec_cm_ctl(mode='start')
        self.logger.info(start_msg)
        self.assertIn(self.constant.cm_start_success_msg,
                      start_msg, '启动集群失败')
        time.sleep(30)
        status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
        self.logger.info(status)
        self.assertIn('cluster_state   : Normal', status, '执行失败')

        step10 = "-----step10:DSS_HOME路径权限不足时，将节点从集群中移除，" \
                 "不走服务端，不指定-D DSS_HOME参数;expect:合理报错-----"
        self.logger.info(step10)
        execute_cmd = f"source {macro.DB_ENV_PATH};" \
            f"chmod 000 {macro.DSS_INSTANCE};" \
            f"dsscmd unreghl -t 1;" \
            f"chmod 700 {macro.DSS_INSTANCE}"
        self.logger.info(execute_cmd)
        execute_msg = self.common.get_sh_result(self.primary_node, execute_cmd)
        self.assertIn("dss_inst.ini does not exist",
                      execute_msg, "执行失败" + step10)
        self.assertIn("Failed to unregister", execute_msg, "执行失败" + step10)

    def tearDown(self):
        self.logger.info("-----无需清理环境-----")
        status = self.primary_sh.exec_cm_ctl(mode='query', param='-Cv')
        self.logger.info(status)
        self.assertIn('cluster_state   : Normal', status, '执行失败')
        self.logger.info(f"-----{os.path.basename(__file__)} end-----")
